home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / System / lpDaemon SRC / Common Sources / Backgrounder.C next >
Encoding:
C/C++ Source or Header  |  1993-02-12  |  3.8 KB  |  165 lines  |  [TEXT/KAHL]
  1. /************************************************************************
  2.  *                                                                        *
  3.  *    BackGrounder.C                                                        *
  4.  *                                                                        *
  5.  *  Written by Casper Boon, April, 1992.                                *
  6.  *                                                                        *
  7.  *    © 1992, CorkScrew Computer Technologies.                            *
  8.  *                                                                        *
  9.  ************************************************************************/
  10.  
  11. #include "BackGrounder.H"
  12.  
  13. typedef struct _BackGroundTask
  14.     {
  15.     struct _BackGroundTask *qLink;
  16.     integer            *flag;
  17.     CallBackProcPtr    callBack;
  18.     Ptr                param;
  19.     LongInt            timeout;
  20.     } BackGroundTask, *BGTaskPtr;
  21.  
  22. typedef struct
  23.     {
  24.     BGTaskPtr    qHead;
  25.     BGTaskPtr    qTail;
  26.     } BQHdr, *BQHPtr;
  27.  
  28. static BQHdr bgQueue = { NIL, NIL };
  29. static integer FindFree(void);
  30.  
  31. void AddQueue(BGTaskPtr task, BQHPtr q);
  32. void DelQueue(BGTaskPtr task, BQHPtr q);
  33.  
  34. /************************************************************************
  35.  *                                                                        *
  36.  *                                                                        *
  37.  ************************************************************************/
  38. void AddQueue(BGTaskPtr task, BQHPtr q)
  39. {
  40.     task->qLink = NIL;
  41.  
  42.     if (q->qHead == NIL) q->qHead = q->qTail = task;
  43.     else
  44.         {
  45.         (q->qTail)->qLink = task;
  46.         q->qTail = task;
  47.         }
  48. }
  49.  
  50. /************************************************************************
  51.  *                                                                        *
  52.  *                                                                        *
  53.  ************************************************************************/
  54. void DelQueue(BGTaskPtr task, BQHPtr q)
  55. {
  56.     register BGTaskPtr    tmp;
  57.  
  58.               /* the easy case first, the item is the first in the queue */
  59.     if ( (tmp = q->qHead) == task)
  60.         {
  61.         q->qHead = tmp->qLink;
  62.         if (q->qTail == task)
  63.             q->qTail = NIL;
  64.         }
  65.     else
  66.         {
  67.         /* look for the item in the queue before the one we are removing */
  68.         while (tmp && tmp->qLink && tmp->qLink != task)
  69.             tmp = tmp->qLink;
  70.  
  71.         if (tmp->qLink && tmp->qLink == task)
  72.             {
  73.             tmp->qLink = task->qLink;
  74.             if (q->qTail == task)
  75.                 q->qTail = tmp;
  76.             }
  77.         }
  78. }
  79.  
  80.  
  81. /************************************************************************
  82.  *                                                                        *
  83.  *                                                                        *
  84.  ************************************************************************/
  85. Ptr Background(integer *flag, CallBackProcPtr proc, Ptr param)
  86. {
  87.     return Timeout(flag, proc, param, -1L);
  88. }
  89.  
  90. /************************************************************************
  91.  *                                                                        *
  92.  *                                                                        *
  93.  ************************************************************************/
  94. Ptr Timeout(integer *flag, CallBackProcPtr proc,
  95.                                     Ptr param, LongInt timeout)
  96. {
  97.     BGTaskPtr    task;
  98.  
  99.     RunBackground();
  100.  
  101.     task = (BGTaskPtr)NewPtr(sizeof(BackGroundTask));
  102.  
  103.     task->qLink = NIL;
  104.     task->flag = flag;
  105.     task->callBack = proc;
  106.     task->param = param;
  107.     if (timeout != -1)
  108.         task->timeout = timeout + Ticks;
  109.     else
  110.         task->timeout = -1;
  111.  
  112.     AddQueue(task, &bgQueue);
  113.     return (Ptr)task;
  114. }
  115.  
  116. /************************************************************************
  117.  *                                                                        *
  118.  *                                                                        *
  119.  ************************************************************************/
  120. void KillBackground(Ptr ident)
  121. {
  122.     BGTaskPtr    task = (BGTaskPtr)ident;
  123.  
  124.     DelQueue(task, &bgQueue);
  125.     DisposPtr((Ptr)task);
  126. }
  127.  
  128.  
  129. /************************************************************************
  130.  *                                                                        *
  131.  *                                                                        *
  132.  ************************************************************************/
  133. void RunBackground()
  134. {
  135.     BGTaskPtr    task, end;
  136.     Boolean        first = TRUE;
  137.     CallBackProcPtr proc;
  138.  
  139.     do    {
  140.         if ( first )
  141.             {
  142.             task = (BGTaskPtr)bgQueue.qHead,
  143.             end = (BGTaskPtr)bgQueue.qTail;
  144.             }
  145.         else
  146.             task = (BGTaskPtr)task->qLink;
  147.  
  148.         if ( !task )    break;
  149.  
  150.         first = FALSE;
  151.  
  152.         if ( (*(task->flag) <= 0) ||    /* task has completed */
  153.                 ( (task->timeout > 0) &&    /* has a timeout value */
  154.                     (task->timeout <= Ticks) ) )    /* and has timed out */
  155.             {
  156.             proc = task->callBack;
  157.             DelQueue(task, &bgQueue);
  158.             (*proc)(*(task->flag), task->param);
  159.             DisposPtr((Ptr)task);
  160.             first = TRUE;
  161.             }
  162.         }
  163.     while ( task != end );
  164. }
  165.